"""
项目相关数据模型

定义项目和项目视频关联的数据模型。
"""

from datetime import datetime
from typing import Dict, Any, Optional, List
from enum import Enum

from sqlalchemy import Column, Integer, String, Text, Boolean, ForeignKey, Table, Index, DateTime, Float
from sqlalchemy.orm import relationship

from .base import BaseModel, JSONField


# 项目和视频的多对多关联表
project_videos = Table(
    'project_videos',
    BaseModel.metadata,
    Column('project_id', Integer, ForeignKey('projects.id'), primary_key=True),
    Column('video_id', Integer, ForeignKey('videos.id'), primary_key=True),
    Column('order_index', Integer, default=0),  # 在项目中的排序
    Column('added_at', DateTime, default=datetime.utcnow),
    Index('idx_project_videos_order', 'project_id', 'order_index')
)


class Project(BaseModel):
    """
    项目模型
    
    用于组织和管理视频文件的项目。
    """
    
    __tablename__ = 'projects'
    
    # 项目基本信息
    name = Column(String(200), nullable=False, index=True)
    description = Column(Text, nullable=True)
    
    # 项目状态
    is_active = Column(Boolean, default=True, nullable=False)
    is_template = Column(Boolean, default=False, nullable=False)  # 是否为模板项目
    
    # 项目配置
    settings = Column(Text, nullable=True)  # JSON格式的项目设置
    
    # 输出配置
    output_directory = Column(String(500), nullable=True)
    output_format = Column(String(50), nullable=True)
    
    # 统计信息
    video_count = Column(Integer, default=0, nullable=False)
    total_duration = Column(Float, default=0.0, nullable=False)  # 总时长（秒）
    
    # 关联关系
    videos = relationship(
        "Video",
        secondary=project_videos,
        backref="projects",
        lazy="dynamic"
    )
    
    # 索引
    __table_args__ = (
        Index('idx_project_status', 'is_active', 'is_template'),
        Index('idx_project_name_active', 'name', 'is_active'),
    )
    
    def get_settings_dict(self) -> Dict[str, Any]:
        """获取项目设置字典"""
        return JSONField.deserialize(self.settings) or {}
    
    def set_settings_dict(self, settings: Dict[str, Any]) -> None:
        """设置项目设置字典"""
        self.settings = JSONField.serialize(settings)
    
    def add_video(self, video, order_index: int = None) -> None:
        """添加视频到项目"""
        from sqlalchemy import insert

        if order_index is None:
            order_index = self.video_count

        # 这个方法需要在有session的上下文中调用
        # 实际使用时应该通过仓库模式来操作
        pass
    
    def remove_video(self, video) -> None:
        """从项目中移除视频"""
        # 这个方法需要在有session的上下文中调用
        # 实际使用时应该通过仓库模式来操作
        pass

    def get_videos_ordered(self) -> List:
        """获取按顺序排列的视频列表"""
        # 这个方法需要在有session的上下文中调用
        # 实际使用时应该通过仓库模式来操作
        return []

    def reorder_videos(self, video_ids: List[int]) -> None:
        """重新排序项目中的视频"""
        # 这个方法需要在有session的上下文中调用
        # 实际使用时应该通过仓库模式来操作
        pass

    def duplicate(self, new_name: str) -> 'Project':
        """复制项目"""
        # 这个方法需要在有session的上下文中调用
        # 实际使用时应该通过仓库模式来操作
        return None
    
    @property
    def total_duration_formatted(self) -> str:
        """格式化的总时长"""
        if self.total_duration:
            hours = int(self.total_duration // 3600)
            minutes = int((self.total_duration % 3600) // 60)
            seconds = int(self.total_duration % 60)
            
            if hours > 0:
                return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
            else:
                return f"{minutes:02d}:{seconds:02d}"
        return "00:00"
    
    def get_statistics(self) -> Dict[str, Any]:
        """获取项目统计信息"""
        return {
            'video_count': self.video_count,
            'total_duration': self.total_duration,
            'total_duration_formatted': self.total_duration_formatted,
            'category_distribution': {},
            'resolution_distribution': {},
            'format_distribution': {},
            'average_video_duration': self.total_duration / self.video_count if self.video_count > 0 else 0
        }
    
    def to_dict(self, include_relationships: bool = False) -> Dict[str, Any]:
        """转换为字典"""
        result = super().to_dict(include_relationships)
        
        # 添加计算属性
        result.update({
            'settings_dict': self.get_settings_dict(),
            'total_duration_formatted': self.total_duration_formatted,
            'statistics': self.get_statistics()
        })
        
        # 包含视频列表（如果需要）
        if include_relationships:
            result['videos_ordered'] = []
        
        return result


class ProjectVideo(BaseModel):
    """
    项目视频关联模型
    
    存储项目和视频之间的关联信息（如果需要额外字段）。
    """
    
    __tablename__ = 'project_video_details'
    
    # 关联信息
    project_id = Column(Integer, ForeignKey('projects.id'), nullable=False)
    video_id = Column(Integer, ForeignKey('videos.id'), nullable=False)
    
    # 在项目中的配置
    order_index = Column(Integer, default=0, nullable=False)
    start_time = Column(Float, default=0.0, nullable=False)  # 开始时间（秒）
    end_time = Column(Float, nullable=True)  # 结束时间（秒，None表示到视频结尾）
    
    # 视频在项目中的设置
    volume = Column(Float, default=1.0, nullable=False)  # 音量 0.0-1.0
    is_muted = Column(Boolean, default=False, nullable=False)
    
    # 效果和滤镜
    effects = Column(Text, nullable=True)  # JSON格式的效果配置
    
    # 关联关系
    project = relationship("Project")
    video = relationship("Video")
    
    # 索引
    __table_args__ = (
        Index('idx_project_video_order', 'project_id', 'order_index'),
        Index('idx_project_video_unique', 'project_id', 'video_id', unique=True),
    )
    
    def get_effects_dict(self) -> Dict[str, Any]:
        """获取效果配置字典"""
        return JSONField.deserialize(self.effects) or {}
    
    def set_effects_dict(self, effects: Dict[str, Any]) -> None:
        """设置效果配置字典"""
        self.effects = JSONField.serialize(effects)
    
    @property
    def duration(self) -> Optional[float]:
        """在项目中的持续时间"""
        if self.end_time:
            return self.end_time - self.start_time
        elif self.video and self.video.duration:
            return self.video.duration - self.start_time
        return None
    
    def to_dict(self, include_relationships: bool = False) -> Dict[str, Any]:
        """转换为字典"""
        result = super().to_dict(include_relationships)
        
        # 添加计算属性
        result.update({
            'effects_dict': self.get_effects_dict(),
            'duration': self.duration
        })
        
        return result
